home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Games / WHDLoad / Src / gci / winmem.c < prev   
Encoding:
C/C++ Source or Header  |  2000-08-10  |  8.9 KB  |  340 lines
  1. /*************************************************************************
  2. ;  :Module.    winmem.c
  3. ;  :Author.    Bert Jahn
  4. ;  :EMail.    wepl@whdload.org
  5. ;  :Address.    Franz-Liszt-Straße 16, Rudolstadt, 07404, Germany
  6. ;  :Version.    $Id: winmem.c 1.4 2000/08/10 21:38:10 jah Exp jah $
  7. ;  :History.    21.03.00 separated from main
  8. ;  :Copyright.    All Rights Reserved
  9. ;  :Language.    C
  10. ;  :Translator.    GCC
  11. *************************************************************************/
  12.  
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include <exec/execbase.h>
  17. #include <libraries/mui.h>
  18. #include <mui/HexEdit_mcc.h>
  19.  
  20. #include <clib/alib_protos.h>
  21. #include <clib/gadtools_protos.h>
  22. #include <clib/muimaster_protos.h>
  23. #include <clib/utility_protos.h>
  24.  
  25. #include "whddump.h"
  26. #include "WHDLoadGCI.h"
  27.  
  28. /************************************************************************/
  29. /* Compiler Stuff                                                       */
  30. /************************************************************************/
  31.  
  32. #define REG(x) register __ ## x
  33. #define ASM    __asm
  34. #define SAVEDS __saveds
  35.  
  36. /************************************************************************/
  37. /* defines                                */
  38. /************************************************************************/
  39.  
  40. #define MAXWINMEM 10    /* amount of possible memory hexdump windows */
  41. #define MUIA_HexEdit_My    TAG_USER + 1
  42.  
  43. /************************************************************************/
  44. /* extern variables                            */
  45. /************************************************************************/
  46.  
  47. extern APTR            app,win;
  48. extern struct whddump_header    *header;
  49. extern struct Library        *MUIMasterBase;
  50. extern APTR            mem,emem,slave;
  51. extern const char* StringHexAccept;
  52.  
  53. /************************************************************************/
  54. /* static variables                            */
  55. /************************************************************************/
  56.  
  57. static APTR win_mem[MAXWINMEM];        /* memory hexdump windows */
  58. static APTR gad_hex[MAXWINMEM];        /* hex display gadgets */
  59. static APTR gad_goto[MAXWINMEM];    /* goto gadgets */
  60.  
  61. static struct MUI_CustomClass *HexClass;
  62.  
  63. static struct NewMenu MenuDataMem[] =
  64. {
  65.     MENUBASE
  66.     { NM_TITLE, "Memory"    , 0 ,0 ,0 ,(APTR)MEN_MEMORY    },\
  67.     { NM_ITEM ,  "Goto"    ,"G",0 ,0 ,(APTR)MEN_GOTO0    },\
  68.     { NM_END,NULL,0,0,0,(APTR)0 },
  69. };
  70.  
  71. /************************************************************************/
  72. /* function declarations                        */
  73. /************************************************************************/
  74.  
  75. void *    wmem_init    (void);
  76. void    wmem_finit    (void);
  77.  
  78. /************************************************************************/
  79.  
  80. struct HexData {
  81.     int low_bound;
  82.     int high_bound;
  83.     int base_address;
  84.     int len_base;
  85.     int len_off;
  86. };
  87.  
  88. SAVEDS ULONG
  89. mNew(
  90.     struct IClass *cl,
  91.     Object *obj,
  92.     Msg msg
  93. ) {
  94.     struct TagItem *tags,*tag;
  95.     int i;
  96.     struct HexData tmp = {0,0,0,0,0};
  97.  
  98.     for (tags=((struct opSet *)msg)->ops_AttrList; (tag=NextTagItem(&tags)); )
  99.     {
  100.         switch (tag->ti_Tag)
  101.         {
  102.             case MUIA_HexEdit_LowBound: tmp.low_bound = tag->ti_Data; break;
  103.             case MUIA_HexEdit_HighBound: tmp.high_bound = tag->ti_Data; break;
  104.             case MUIA_HexEdit_BaseAddressOffset: tmp.base_address = tag->ti_Data; break;
  105.             case MUIA_HexEdit_AddressChars:
  106.                 i = tmp.high_bound + tmp.base_address;
  107.                 tmp.len_base =    i < 0x10000 ? 4 :
  108.                                 i < 0x100000 ? 5 :
  109.                                 i < 0x1000000 ? 6 :
  110.                                 i < 0x10000000 ? 7 : 8;
  111.                 if (tmp.low_bound + tmp.base_address) {
  112.                     i = tmp.high_bound - tmp.low_bound;
  113.                     tmp.len_off =    i < 0x1000 ? 3 :
  114.                                     i < 0x10000 ? 4 :
  115.                                     i < 0x100000 ? 5 : 6;
  116.                 } else {
  117.                     tmp.len_off = 0;
  118.                 }
  119.                 tag->ti_Data = tmp.len_base + (tmp.len_off ? 1 + tmp.len_off : 0);
  120.                 break;
  121.         }
  122.     }
  123.  
  124.     if (!(obj = (Object *)DoSuperMethodA(cl,obj,msg))) return(0);
  125.  
  126.     memcpy(INST_DATA(cl,obj), &tmp, sizeof(tmp));
  127.  
  128.     return ((ULONG)obj);
  129. }
  130.  
  131. SAVEDS ULONG
  132. mSet(
  133.     struct IClass *cl,
  134.     Object *obj,
  135.     Msg msg
  136. ) {
  137.     struct TagItem *tags,*tag;
  138.     char *s;
  139.     int i;
  140.  
  141.     for (tags=((struct opSet *)msg)->ops_AttrList; (tag=NextTagItem(&tags)); )
  142.     {
  143.         switch (tag->ti_Tag)
  144.         {
  145.             case MUIA_HexEdit_My:
  146.                 get( gad_goto[tag->ti_Data], MUIA_String_Contents, &s );
  147.                 i = atoi( s );
  148.                 set( obj, MUIA_HexEdit_CursorAddress, 1000 );
  149.                 break;
  150.         }
  151.     }
  152.  
  153.     return DoSuperMethodA(cl,obj,msg);
  154. }
  155.  
  156. SAVEDS ULONG
  157. mCreateDisplayAddress(
  158.     struct IClass *cl,
  159.     Object *obj,
  160.     struct MUIP_HexEdit_CreateDisplayAddress *msg
  161. ) {
  162.     struct HexData *d = INST_DATA(cl,obj);
  163.     ULONG address;
  164.     UBYTE i;
  165.     UBYTE *hextable = "0123456789ABCDEF";
  166.  
  167.     address = (d->base_address + msg->address) << (32 - d->len_base * 4);
  168.     for(i = 0; i < d->len_base; i++)
  169.     {
  170.         *(*msg->cp)++ = hextable[address >> (32 - 4)];
  171.         address <<= 4;
  172.     }
  173.  
  174.     address = (msg->address - d->low_bound) << (32 - d->len_off * 4);
  175.     if (d->len_off) {
  176.         *(*msg->cp)++ = (unsigned char) '·';
  177.         for(i = 0; i < d->len_off; i++)
  178.         {
  179.             *(*msg->cp)++ = hextable[address >> (32 - 4)];
  180.             address <<= 4;
  181.         }
  182.     }
  183.  
  184.     return(TRUE);
  185. }
  186.  
  187. /*
  188. SAVEDS ASM ULONG
  189. HexDispatcher(
  190.     REG(a0) struct IClass *cl,
  191.     REG(a2) Object *obj,
  192.     REG(a1) Msg msg
  193. */
  194. SAVEDS ULONG
  195. HexDispatcher(
  196.     struct IClass *cl __asm("a0"),
  197.     Object *obj __asm("a2"),
  198.     Msg msg __asm("a1")
  199. ) {
  200.     switch (msg->MethodID)
  201.     {
  202.         case OM_NEW                : return(mNew            (cl,obj,(APTR)msg));
  203.         case OM_SET                : return(mSet            (cl,obj,(APTR)msg));
  204.         case MUIM_HexEdit_CreateDisplayAddress    : return(mCreateDisplayAddress    (cl,obj,(APTR)msg));
  205.     }
  206.     return(DoSuperMethodA(cl,obj,msg));
  207. }
  208.  
  209. /****************************************************************************/
  210.  
  211. void * wmem_init() {
  212.     return HexClass = MUI_CreateCustomClass(NULL,MUIC_HexEdit,NULL,sizeof(struct HexData),HexDispatcher);
  213. }
  214.  
  215. void wmem_finit() {
  216.     if (HexClass) MUI_DeleteCustomClass(HexClass);
  217. }
  218.  
  219. /****************************************************************************/
  220.  
  221. void
  222. wmem_make(
  223.     int adr        /* start address (logical) of memory to display */
  224. ) {
  225.     int n;
  226.     APTR prop;
  227.     ULONG open;
  228.     APTR low,high;
  229.     ULONG off,cur;
  230.     char *title;
  231.     
  232.     /*
  233.      *  check if there is a free window left
  234.      *  if window closed dispose it
  235.      */
  236.     for (n=0; (n<MAXWINMEM) && win_mem[n]; n++) {
  237.         get(win_mem[n],MUIA_Window_Open,&open);
  238.         if (!open) {
  239.             DoMethod(app,OM_REMMEMBER,win_mem[n]);
  240.             MUI_DisposeObject(win_mem[n]);
  241.             win_mem[n] = NULL;
  242.             break;
  243.         }
  244.     }
  245.     if (n==MAXWINMEM) {
  246.         MUI_Request(app,win,0,NULL,"Ok","Sorry, too many windows already open.");
  247.         return;
  248.     }
  249.     
  250.     /*
  251.      *  check which memory is requested
  252.      */
  253.     if (adr < header->wdh_BaseMemSize) {
  254.         title = "Base Memory (Chip)";
  255.         low = mem;
  256.         high = ((UBYTE*)mem) + header->wdh_BaseMemSize - 1;
  257.         off = -(ULONG)mem;
  258.         cur = adr;
  259.     } else if ((adr >= header->wdh_ExpMemLog) && (adr < header->wdh_ExpMemLog + header->wdh_ExpMemLen)) {
  260.         title = "Expansion Memory (Fast)";
  261.         low = emem;
  262.         high = ((UBYTE*)emem) + header->wdh_ExpMemLen - 1;
  263.         off = header->wdh_ExpMemLog - (ULONG)emem;
  264.         cur = adr - header->wdh_ExpMemLog;
  265.     } else if ((adr >= header->wdh_SlaveLog) && (adr < header->wdh_SlaveLog + header->wdh_SlaveLen)) {
  266.         title = "Slave Memory";
  267.         low = slave;
  268.         high = ((UBYTE*)slave) + header->wdh_SlaveLen - 1;
  269.         off = header->wdh_SlaveLog - (ULONG)slave;
  270.         cur = adr - header->wdh_SlaveLog;
  271.     } else {
  272.         MUI_Request(app,win,0,NULL,"Ok","Sorry, address is outside the defined memory.");
  273.         return;
  274.     }
  275.  
  276.     /*
  277.      *  create the window
  278.      */
  279.     win_mem[n] = WindowObject,
  280.         MUIA_Window_Title, title,
  281.         MUIA_Window_ID   , n + MAKE_ID('M','E','M','0'),
  282.         MUIA_Window_Menustrip, MUI_MakeObject(MUIO_MenustripNM,MenuDataMem,0),
  283.         WindowContents, VGroup,
  284.             Child, HGroup,
  285.                 Child, Label2("Goto Offset:"),
  286.                 Child, gad_goto[n] = BetterStringObject,
  287.                     StringFrame,
  288.                     MUIA_String_Accept , StringHexAccept,
  289.                     MUIA_String_MaxLen , 10,
  290.                     MUIA_String_Format , MUIV_String_Format_Right,
  291.                     MUIA_ShortHelp, "Goto Offset",
  292.                     MUIA_String_Contents, "$",
  293.                     End,
  294.                 End,
  295.             Child, HGroup,
  296.                 Child, gad_hex[n] = NewObject(HexClass->mcc_Class,0, VirtualFrame,
  297.                     MUIA_HexEdit_LowBound, low,
  298.                     MUIA_HexEdit_HighBound, high,
  299.                     MUIA_HexEdit_BaseAddressOffset, off,
  300.                     MUIA_HexEdit_AddressChars, 0,    /* must be after Low, High and BaseAddressOffset! */
  301.                     MUIA_HexEdit_EditMode, TRUE,
  302.                     MUIA_HexEdit_SelectMode, MUIV_HexEdit_SelectMode_Byte,
  303.                     //MUIA_HexEdit_CursorAddress, cur,
  304.                     MUIA_CycleChain, 1,
  305.                     End,
  306.                 Child, prop = ScrollbarObject,
  307.                     MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Right,
  308.                     End,
  309.                 End,
  310.             End,
  311.         End;
  312.     if (!win_mem[n]) {
  313.         MUI_Request(app,win,0,NULL,"Ok","Couldn't open window.");
  314.         return;
  315.     }
  316.  
  317.     set(gad_hex[n],MUIA_HexEdit_BaseAddressOffset,off);
  318.     set(gad_hex[n],MUIA_HexEdit_AddressChars,2);
  319.  
  320.     /*
  321.      *  add window to application and open it
  322.      */
  323.     DoMethod(app,OM_ADDMEMBER,win_mem[n]);
  324.     set(gad_hex[n],MUIA_HexEdit_PropObject,prop);
  325.     DoMethod(win_mem[n],MUIM_Notify,MUIA_Window_CloseRequest,TRUE,win_mem[n],3,MUIM_Set,MUIA_Window_Open,FALSE);
  326.     DoMethod(gad_goto[n],MUIM_Notify,MUIA_String_Accept,TRUE,gad_hex[n],3,MUIM_Set,MUIA_HexEdit_My,n);
  327.     set(win_mem[n],MUIA_Window_Open,TRUE);
  328.  
  329. }
  330.  
  331. /****************************************************************************/
  332.  
  333. void wmem_goto ( int num )
  334. {
  335.  
  336. }
  337.  
  338. /****************************************************************************/
  339.  
  340.